package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.zzw.TCaseInfo;
import com.ruoyi.common.core.domain.zzw.VO.*;
import com.ruoyi.system.mapper.SysDictDataMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.TCaseInfoMapper;
import com.ruoyi.system.service.ITCaseInfoService;

/**
 * 民转刑事案件详情Service业务层处理
 * 
 * @author ruoyi
 * @date 2023-11-21
 */
@Service
public class TCaseInfoServiceImpl implements ITCaseInfoService 
{
    @Autowired
    private TCaseInfoMapper tCaseInfoMapper;
    @Autowired
    private SysDictDataMapper sysDictDataMapper;

    /**
     * 查询民转刑事案件详情
     * 
     * @param cCaseId 民转刑事案件详情主键
     * @return 民转刑事案件详情
     */
    @Override
    public TCaseInfo selectTCaseInfoByCCaseId(Long cCaseId)
    {
        return tCaseInfoMapper.selectTCaseInfoByCCaseId(cCaseId);
    }

    /**
     * 查询民转刑事案件详情列表
     * 
     * @param tCaseInfo 民转刑事案件详情
     * @return 民转刑事案件详情
     */
    @Override
    public List<TCaseInfoListVO> selectTCaseInfoList(TCaseInfo tCaseInfo)
    {
        List<TCaseInfoListVO> collect = tCaseInfoMapper.selectTCaseInfoList(tCaseInfo).stream().map(item -> {
            item.setCCaseTypeName(getName(String.valueOf(item.getCCaseType())));
            List<String> value=new ArrayList<>();
            value.add(item.getLongitude());
            value.add(item.getLatitude());
            item.setValue(value);
            return item;
        }).collect(Collectors.toList());
        return collect;
    }

    /**
     * 新增民转刑事案件详情
     * 
     * @param tCaseInfo 民转刑事案件详情
     * @return 结果
     */
    @Override
    public int insertTCaseInfo(TCaseInfo tCaseInfo)
    {
        return tCaseInfoMapper.insertTCaseInfo(tCaseInfo);
    }

    /**
     * 修改民转刑事案件详情
     * 
     * @param tCaseInfo 民转刑事案件详情
     * @return 结果
     */
    @Override
    public int updateTCaseInfo(TCaseInfo tCaseInfo)
    {
        return tCaseInfoMapper.updateTCaseInfo(tCaseInfo);
    }

    /**
     * 批量删除民转刑事案件详情
     * 
     * @param cCaseIds 需要删除的民转刑事案件详情主键
     * @return 结果
     */
    @Override
    public int deleteTCaseInfoByCCaseIds(Long[] cCaseIds)
    {
        return tCaseInfoMapper.deleteTCaseInfoByCCaseIds(cCaseIds);
    }

    /**
     * 删除民转刑事案件详情信息
     * 
     * @param cCaseId 民转刑事案件详情主键
     * @return 结果
     */
    @Override
    public int deleteTCaseInfoByCCaseId(Long cCaseId)
    {
        return tCaseInfoMapper.deleteTCaseInfoByCCaseId(cCaseId);
    }

    @Override
    public  List<RenderingDataVO> byRegion() {
        List<RenderingDataVO> vo=tCaseInfoMapper.byRegion();
        List<RenderingDataVO> collect = vo.stream().map(item -> {
            List<String> value = new ArrayList<>();
            value.add(String.valueOf(item.getCount()));
            value.add(item.getLongitude());
            value.add(item.getLatitude());
            item.setValue(value);
            item.setSelected(true);
            return item;
        }).collect(Collectors.toList());
        return collect;
    }

    private String getName(String item) {
        Map<String,String> maps=new HashMap<>();
        List<SysDictData> caseType = sysDictDataMapper.selectDictDataByType("case_type");
        for (SysDictData sysDictData : caseType) {
            maps.put(sysDictData.getDictValue(),sysDictData.getDictLabel());
        }
        String name = maps.get(item);
        return name;
    }

    @Override
    public List<caseInfoAverageVO> average() {
        List<caseInfoAverageVO> vo=  tCaseInfoMapper.average();
        List<caseInfoAverageVO> collect = vo.stream().map(item -> {
            item.setCaseTypeName(getName(item.getCaseTypeName()));
            return item;
        }).collect(Collectors.toList());
        return collect;
    }

    @Override
    public byTypeVO byType(String type) {
        //设置潜在因素转隐患概率
        type="c_qzyszyh";
        List<byType> qzyszyh = tCaseInfoMapper.byType(type).stream().map(item -> {
            item.setName(getName(item.getName()));
            return item;
        }).collect(Collectors.toList());
        byTypeVO vo=new byTypeVO();
        vo.setQzyszyh(qzyszyh);
        //处置隐患概率
        type="c_czyh";
        List<byType> czyh = tCaseInfoMapper.byType(type).stream().map(item -> {
            item.setName(getName(item.getName()));
            return item;
        }).collect(Collectors.toList());
        vo.setCzyh(czyh);
        //潜在因素转刑事案件概率
        type="c_qzyszxs";
        List<byType> qzyszxs = tCaseInfoMapper.byType(type).stream().map(item -> {
            item.setName(getName(item.getName()));
            return item;
        }).collect(Collectors.toList());
        vo.setQzyszxs(qzyszxs);
        return vo ;
    }


}
